home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / flight-of-the-museum.swf / scripts / engine / dynamicObjects / Plane.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  12.5 KB  |  471 lines
  1. package engine.dynamicObjects
  2. {
  3.    import copy.CopyBank;
  4.    import engine.BitmapLibrary;
  5.    import engine.Engine;
  6.    import engine.WorldScene;
  7.    import flash.display.BitmapData;
  8.    import flash.events.KeyboardEvent;
  9.    import flash.ui.Keyboard;
  10.    
  11.    public class Plane extends DynamicObject
  12.    {
  13.        
  14.       
  15.       private var _enabled:Boolean = true;
  16.       
  17.       private var _pitchInput:Number = 0;
  18.       
  19.       private var _newBombTimer:Number = 0;
  20.       
  21.       private var _pitchAccel:Number = 0;
  22.       
  23.       private var _tempDamage:Number = 0;
  24.       
  25.       private var _ink:Number = 0;
  26.       
  27.       private var _pitch:Number = 0;
  28.       
  29.       private var _roll:Number = 0;
  30.       
  31.       private var _listenersSet:Boolean = false;
  32.       
  33.       private var _trackedOutOfFuel:Boolean = false;
  34.       
  35.       private var _damageProtectionTimer:Number = 0;
  36.       
  37.       private var _pitchVel:Number = 0;
  38.       
  39.       private var _fuel:Number = 100;
  40.       
  41.       private var _bankOffset:Number = 0;
  42.       
  43.       private var _deathSpiral:Number = 0;
  44.       
  45.       private var _life:Number = 100;
  46.       
  47.       private var _vel:Number = 13;
  48.       
  49.       private var _cFrame:Number = 1;
  50.       
  51.       public function Plane()
  52.       {
  53.          _enabled = true;
  54.          _listenersSet = false;
  55.          _cFrame = 1;
  56.          _pitchVel = 0;
  57.          _pitchAccel = 0;
  58.          _pitchInput = 0;
  59.          _pitch = 0;
  60.          _roll = 0;
  61.          _ink = 0;
  62.          _damageProtectionTimer = 0;
  63.          _fuel = 100;
  64.          _trackedOutOfFuel = false;
  65.          _tempDamage = 0;
  66.          _life = 100;
  67.          _bankOffset = 0;
  68.          _deathSpiral = 0;
  69.          _newBombTimer = 0;
  70.          _vel = 13;
  71.          _bmdArray = BitmapLibrary.Clips.DYN_Plane3D;
  72.          super(_bmdArray[0]);
  73.          _animationMethod = ANIM_METHODS.Arbitrary;
  74.          _drawMethod = DMETHOD.Slow;
  75.          _lockScale = true;
  76.          _persistent = true;
  77.          s = 1.45;
  78.          z = 2.5;
  79.       }
  80.       
  81.       public function init() : *
  82.       {
  83.          trace("Plane.init()");
  84.          if(!_listenersSet)
  85.          {
  86.             setInputListeners();
  87.             _listenersSet = true;
  88.          }
  89.          _trackedOutOfFuel = false;
  90.          Main.Instance.startPropeller();
  91.          _enabled = true;
  92.          _damageProtectionTimer = 0;
  93.          _deathSpiral = 0;
  94.          _newBombTimer = 0;
  95.          r = 0;
  96.          _pitch = 0;
  97.          _pitchVel = 0;
  98.          _pitchAccel = 0;
  99.          _pitchInput = 0;
  100.          _deathSpiral = 0;
  101.          _ink = 0;
  102.          _tempDamage = 0;
  103.          _life = 100;
  104.          _fuel = 100;
  105.          _enabled = true;
  106.          vis = true;
  107.          x = WorldScene.Instance.MissionDetails.StartLoc.x;
  108.          y = WorldScene.Instance.MissionDetails.StartLoc.y;
  109.       }
  110.       
  111.       public function get Life() : Number
  112.       {
  113.          return _life;
  114.       }
  115.       
  116.       public function deflect() : *
  117.       {
  118.          _pitch += Math.PI;
  119.       }
  120.       
  121.       private function dropBomb() : *
  122.       {
  123.          WorldScene.Instance.dropBomb();
  124.       }
  125.       
  126.       public function deflectUp() : *
  127.       {
  128.          _pitch = -Math.PI / 2;
  129.       }
  130.       
  131.       override public function fStep() : *
  132.       {
  133.          var tFrame:Number = NaN;
  134.          var bFlip:Boolean = false;
  135.          var id:* = undefined;
  136.          super.fStep();
  137.          --_ink;
  138.          --_damageProtectionTimer;
  139.          if(_enabled)
  140.          {
  141.             _fuel -= 0.05;
  142.             Engine.Instance.Fuel = _fuel;
  143.             if(_fuel < 0)
  144.             {
  145.                --_life;
  146.             }
  147.             --_newBombTimer;
  148.             if(_pitchInput > 0)
  149.             {
  150.                _pitchAccel += 0.0012;
  151.                if(_pitchAccel > 0.18)
  152.                {
  153.                   _pitchAccel = 0.18;
  154.                }
  155.             }
  156.             if(_pitchInput < 0)
  157.             {
  158.                _pitchAccel -= 0.0012;
  159.                if(_pitchAccel < -0.18)
  160.                {
  161.                   _pitchAccel = -0.18;
  162.                }
  163.             }
  164.             if(_pitchInput == 0)
  165.             {
  166.                _pitchAccel = 0;
  167.                _pitchVel *= 0.9;
  168.             }
  169.             _tempDamage *= 0.98;
  170.             if(_tempDamage > 1)
  171.             {
  172.                if(Math.random() * _tempDamage > 1)
  173.                {
  174.                   _pitchVel += (Math.random() * _tempDamage - _tempDamage / 2) * 0.1;
  175.                   _pitchAccel = (Math.random() * _tempDamage - _tempDamage / 2) * 0.05;
  176.                }
  177.             }
  178.             if(_life > 0)
  179.             {
  180.                if(_ink > 0)
  181.                {
  182.                   _pitchVel += _pitchAccel * 0.25;
  183.                   if(Math.random() < 0.2)
  184.                   {
  185.                      id = new InkDrop();
  186.                      WorldScene.Instance.createFX(this,id);
  187.                      id.vx = vx * 0.6;
  188.                   }
  189.                }
  190.                else
  191.                {
  192.                   _pitchVel += _pitchAccel;
  193.                }
  194.                if(_pitchVel > 0.08)
  195.                {
  196.                   _pitchVel = 0.08;
  197.                }
  198.                if(_pitchVel < -0.08)
  199.                {
  200.                   _pitchVel = -0.08;
  201.                }
  202.                if(y < -50)
  203.                {
  204.                   _pitch = Math.PI / 4;
  205.                }
  206.                if(x < -50)
  207.                {
  208.                   _pitch = 0;
  209.                }
  210.                if(x > 10080)
  211.                {
  212.                   _pitch = -Math.PI;
  213.                }
  214.                _pitch += _pitchVel;
  215.                if(_pitch < 0)
  216.                {
  217.                   _pitch = Math.PI * 2 + _pitch;
  218.                }
  219.                if(_pitch > Math.PI * 2)
  220.                {
  221.                   _pitch -= Math.PI * 2;
  222.                }
  223.                vx = _vel * Math.cos(_pitch);
  224.                vy = _vel * Math.sin(_pitch);
  225.                r = _pitch;
  226.                bFlip = false;
  227.                if(r > Math.PI / 2 && r < Math.PI * 2 - Math.PI / 2)
  228.                {
  229.                   bFlip = true;
  230.                }
  231.                if(bFlip)
  232.                {
  233.                   ++_bankOffset;
  234.                   if(_bankOffset >= 25)
  235.                   {
  236.                      _bankOffset = 25;
  237.                   }
  238.                }
  239.                else
  240.                {
  241.                   --_bankOffset;
  242.                   if(_bankOffset <= 0)
  243.                   {
  244.                      _bankOffset = 0;
  245.                   }
  246.                }
  247.             }
  248.             if(y > 1300)
  249.             {
  250.                if(_life > 0)
  251.                {
  252.                   if(Math.random() > 0.5)
  253.                   {
  254.                      Engine.Instance.setPopupMessage(CopyBank.Instance.CrashTaunt);
  255.                   }
  256.                   damage(30);
  257.                   WorldScene.Instance.generatePlaneExplosion(this);
  258.                   _pitch = Math.PI / -2;
  259.                   Main.Instance.playSound("hit");
  260.                }
  261.                else
  262.                {
  263.                   Engine.Instance.setPopupMessage(CopyBank.Instance.PlaneDead);
  264.                   vx = 0;
  265.                   vy = 0;
  266.                   _enabled = false;
  267.                   WorldScene.Instance.killPlane();
  268.                   Main.Instance.playSound("hitGround");
  269.                   Main.Instance.stopPropeller();
  270.                   WorldScene.Instance.generatePlaneExplosion(this,25);
  271.                }
  272.             }
  273.             if(Life <= 0)
  274.             {
  275.                _tempDamage = 0;
  276.                ++_deathSpiral;
  277.                vy += 0.5;
  278.                r = getRadians(x,y,x + vx,y + vy);
  279.             }
  280.             tFrame = _pitchVel * 85 + _bankOffset + _deathSpiral;
  281.             if(tFrame > 49)
  282.             {
  283.                tFrame -= 49;
  284.             }
  285.             if(tFrame < 1)
  286.             {
  287.                tFrame = 49 + tFrame;
  288.             }
  289.             _cFrame = tFrame;
  290.             _currentFrame = Math.floor(_cFrame);
  291.          }
  292.          else
  293.          {
  294.             vx = 0;
  295.             vy = 0;
  296.          }
  297.       }
  298.       
  299.       public function damage(inDamage:Number) : *
  300.       {
  301.          if(_damageProtectionTimer < 0)
  302.          {
  303.             _life -= inDamage;
  304.             _tempDamage = 1 + inDamage * 0.05;
  305.             if(_life > 0)
  306.             {
  307.                _damageProtectionTimer = inDamage * 1.5;
  308.             }
  309.             else if(_enabled)
  310.             {
  311.                Main.Instance.setDeathPropeller();
  312.             }
  313.          }
  314.       }
  315.       
  316.       public function deflectDown() : *
  317.       {
  318.          _pitch = Math.PI / 2;
  319.       }
  320.       
  321.       private function setInputListeners() : *
  322.       {
  323.          WorldScene.Instance.stage.addEventListener(KeyboardEvent.KEY_DOWN,p_keyDown);
  324.          WorldScene.Instance.stage.addEventListener(KeyboardEvent.KEY_UP,p_keyUp);
  325.       }
  326.       
  327.       public function get TempDamage() : Number
  328.       {
  329.          return _tempDamage;
  330.       }
  331.       
  332.       public function deflectMinor() : *
  333.       {
  334.          if(Math.random() > 0.5)
  335.          {
  336.             _pitch += 0.4;
  337.          }
  338.          else
  339.          {
  340.             _pitch -= 0.4;
  341.          }
  342.       }
  343.       
  344.       public function get Fuel() : Number
  345.       {
  346.          return _fuel;
  347.       }
  348.       
  349.       private function p_keyDown(event:*) : *
  350.       {
  351.          switch(event.keyCode)
  352.          {
  353.             case Keyboard.LEFT:
  354.                _pitchInput = -1.5;
  355.                break;
  356.             case Keyboard.RIGHT:
  357.                _pitchInput = 1.5;
  358.                break;
  359.             case Keyboard.UP:
  360.                _pitchInput = -1.5;
  361.                break;
  362.             case Keyboard.DOWN:
  363.                _pitchInput = 1.5;
  364.                break;
  365.             case Keyboard.SPACE:
  366.                if(_newBombTimer <= 0)
  367.                {
  368.                   dropBomb();
  369.                   _newBombTimer = 20;
  370.                }
  371.          }
  372.       }
  373.       
  374.       public function inkHit() : *
  375.       {
  376.          _ink = 175;
  377.       }
  378.       
  379.       private function p_keyUp(event:*) : *
  380.       {
  381.          switch(event.keyCode)
  382.          {
  383.             case Keyboard.LEFT:
  384.                _pitchInput = 0;
  385.                break;
  386.             case Keyboard.RIGHT:
  387.                _pitchInput = 0;
  388.                break;
  389.             case Keyboard.UP:
  390.                _pitchInput = 0;
  391.                break;
  392.             case Keyboard.DOWN:
  393.                _pitchInput = 0;
  394.          }
  395.       }
  396.       
  397.       override protected function slowDraw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  398.       {
  399.          var extraLayerMode:String = null;
  400.          var csx:Number = NaN;
  401.          var csy:Number = NaN;
  402.          var mtx:Number = NaN;
  403.          var mty:Number = NaN;
  404.          super.slowDraw(inBitmap,inCamX,inCamY);
  405.          extraLayerMode = "";
  406.          if(_damageProtectionTimer > 0 && Math.sin(_damageProtectionTimer * 1) > 0)
  407.          {
  408.             extraLayerMode = "add";
  409.          }
  410.          if(_ink > 0)
  411.          {
  412.             extraLayerMode = "multiply";
  413.          }
  414.          if(extraLayerMode != "")
  415.          {
  416.             _matrix.identity();
  417.             csx = s * (z / _scfl) * xflip;
  418.             csy = s * (z / _scfl) * yflip;
  419.             if(r != 0)
  420.             {
  421.                _matrix.translate(-w / 2,-h / 2);
  422.                _matrix.rotate(r);
  423.                _matrix.translate(w / 2,h / 2);
  424.             }
  425.             if(s != 1 || z != 0)
  426.             {
  427.                _matrix.translate(-w / 2,-h / 2);
  428.                _matrix.scale(csx,csy);
  429.                _matrix.translate(w / 2,h / 2);
  430.             }
  431.             if(!lockX)
  432.             {
  433.                mtx = -inCamX * z + (x - w * csx / 2);
  434.             }
  435.             else
  436.             {
  437.                mtx = -inCamX * 1 + (x - w * csx / 2);
  438.             }
  439.             if(!lockY)
  440.             {
  441.                mty = -inCamY * z + (y - h * csy / 2);
  442.             }
  443.             else
  444.             {
  445.                mty = -inCamY * 1 + (y - h * csy / 2);
  446.             }
  447.             _matrix.translate(mtx,mty);
  448.             if(!_bmd)
  449.             {
  450.                trace("### ERROR _bmd is null - _currentFrame: " + _currentFrame);
  451.             }
  452.             inBitmap.draw(_bmd,_matrix,null,extraLayerMode,null,true);
  453.          }
  454.       }
  455.       
  456.       public function get Ink() : Number
  457.       {
  458.          return _ink;
  459.       }
  460.       
  461.       public function addFuel(fuel:Number) : *
  462.       {
  463.          _fuel += fuel;
  464.          if(_fuel > 100)
  465.          {
  466.             _fuel = 100;
  467.          }
  468.       }
  469.    }
  470. }
  471.